#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
共享充电宝数据仓库 - 后端API服务
提供数据可视化所需的RESTful API接口
"""

import os
import pandas as pd
from flask import Flask, jsonify, request
from flask_cors import CORS
import json
from datetime import datetime
from dotenv import load_dotenv
from ai_service import DataAnalysisAI

# 加载环境变量
load_dotenv()

app = Flask(__name__)
CORS(app)  # 允许跨域访问

# 数据文件路径配置
DATA_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'data', 'ADS')
CLEANED_DATA_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'data', 'cleaned_data')

# 初始化AI分析服务
ai_service = DataAnalysisAI()

def load_csv_data(filename):
    """加载CSV数据文件"""
    try:
        file_path = os.path.join(DATA_PATH, filename)
        if os.path.exists(file_path):
            df = pd.read_csv(file_path, encoding='utf-8')
            return df
        else:
            print(f"文件不存在: {file_path}")
            return None
    except Exception as e:
        print(f"读取文件 {filename} 时出错: {str(e)}")
        return None

def load_cleaned_csv_data(filename):
    """加载清洗后的CSV数据文件"""
    try:
        file_path = os.path.join(CLEANED_DATA_PATH, filename)
        if os.path.exists(file_path):
            df = pd.read_csv(file_path, encoding='utf-8')
            return df
        else:
            print(f"文件不存在: {file_path}")
            return None
    except Exception as e:
        print(f"读取文件 {filename} 时出错: {str(e)}")
        return None

@app.route('/')
def index():
    """API根路径"""
    return jsonify({
        'message': '共享充电宝数据仓库API服务',
        'version': '1.0.0',
        'timestamp': datetime.now().isoformat(),
        'endpoints': [
            '/api/brand-revenue',
            '/api/user-behavior', 
            '/api/time-summary',
            '/api/region-usage',
            '/api/region-heatmap'
        ]
    })

@app.route('/api/brand-revenue')
def get_brand_revenue():
    """获取品牌收入汇总数据"""
    try:
        df = load_csv_data('brand_revenue_summary.csv')
        if df is None:
            # 使用模拟数据
            data = {
                'brands': ['小电', '街电', '怪兽充电', '来电', '搜电', '云充吧', '倍电', '美团充电'],
                'orders': [1250, 980, 850, 720, 650, 480, 380, 320],
                'revenue': [2687.5, 2156.0, 1870.0, 1584.0, 1430.0, 1056.0, 836.0, 704.0],
                'avgPrice': [2.15, 2.20, 2.20, 2.20, 2.20, 2.20, 2.20, 2.20],
                'marketShare': [19.1, 15.0, 13.0, 11.0, 9.9, 7.3, 5.8, 4.9],
                'total': {
                    'totalOrders': 5630,
                    'totalRevenue': 12323.5,
                    'avgMarketPrice': 2.19
                }
            }
        else:
            # 转换为前端需要的格式
            data = {
                'brands': df['品牌名称'].tolist(),
                'orders': df['订单数量'].tolist(),
                'revenue': df['总收入'].tolist(),
                'avgPrice': df['平均单价'].tolist(),
                'marketShare': df['市场份额'].tolist(),
                'total': {
                    'totalOrders': int(df['订单数量'].sum()),
                    'totalRevenue': float(df['总收入'].sum()),
                    'avgMarketPrice': float(df['平均单价'].mean())
                }
            }
        
        return jsonify({
            'success': True,
            'data': data,
            'timestamp': datetime.now().isoformat()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'获取品牌收入数据失败: {str(e)}'
        }), 500

@app.route('/api/user-behavior')
def get_user_behavior():
    """获取用户行为汇总数据"""
    try:
        df = load_csv_data('user_behavior_summary.csv')
        if df is None:
            return jsonify({'error': '数据文件不存在'}), 404
        
        # 计算统计信息
        usage_stats = df['使用次数'].describe()
        consumption_stats = df['总消费'].describe()
        
        # 按使用次数分组统计
        usage_groups = pd.cut(df['使用次数'], bins=[0, 15, 20, 25, 30], labels=['低频用户', '中频用户', '高频用户', '超高频用户'])
        usage_distribution = usage_groups.value_counts().to_dict()
        
        data = {
            'userIds': df['用户ID'].tolist(),
            'usageCount': df['使用次数'].tolist(),
            'totalConsumption': df['总消费'].tolist(),
            'statistics': {
                'totalUsers': len(df),
                'avgUsage': float(usage_stats['mean']),
                'avgConsumption': float(consumption_stats['mean']),
                'maxUsage': int(usage_stats['max']),
                'maxConsumption': float(consumption_stats['max'])
            },
            'distribution': {k: int(v) for k, v in usage_distribution.items() if pd.notna(k)}
        }
        
        return jsonify({
            'success': True,
            'data': data,
            'timestamp': datetime.now().isoformat()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'获取用户行为数据失败: {str(e)}'
        }), 500

@app.route('/api/time-summary')
def get_time_summary():
    """获取时间趋势汇总数据"""
    try:
        df = load_csv_data('time_summary.csv')
        if df is None:
            return jsonify({'error': '数据文件不存在'}), 404

        # 过滤掉空行
        df = df.dropna()

        data = {
            'years': df['年份'].tolist(),
            'records': df['记录数'].tolist(),
            'total': {
                'totalYears': len(df),
                'totalRecords': int(df['记录数'].sum()),
                'avgRecordsPerYear': float(df['记录数'].mean())
            }
        }

        return jsonify({
            'success': True,
            'data': data,
            'timestamp': datetime.now().isoformat()
        })

    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'获取时间趋势数据失败: {str(e)}'
        }), 500

@app.route('/api/region-usage')
def get_region_usage():
    """获取地区使用汇总数据"""
    try:
        df = load_csv_data('region_usage_summary.csv')
        if df is None:
            return jsonify({'error': '数据文件不存在'}), 404
        
        # 按收入排序，取前20名
        df_sorted = df.sort_values('总收入', ascending=False).head(20)
        
        data = {
            'regionIds': df_sorted['地区ID'].tolist(),
            'revenue': df_sorted['总收入'].tolist(),
            'total': {
                'totalRegions': len(df),
                'totalRevenue': float(df['总收入'].sum()),
                'avgRevenue': float(df['总收入'].mean())
            }
        }
        
        return jsonify({
            'success': True,
            'data': data,
            'timestamp': datetime.now().isoformat()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'获取地区使用数据失败: {str(e)}'
        }), 500

@app.route('/api/region-heatmap')
def get_region_heatmap():
    """获取地区热力图数据"""
    try:
        df = load_csv_data('region_heatmap_data.csv')
        if df is None:
            return jsonify({'error': '数据文件不存在'}), 404
        
        # 按省份汇总收入
        province_revenue = df.groupby('省份')['总收入'].sum().sort_values(ascending=False)
        
        # 按城市汇总收入（取前30名）
        city_revenue = df.groupby(['省份', '城市'])['总收入'].sum().sort_values(ascending=False).head(30)
        
        data = {
            'provinces': province_revenue.index.tolist(),
            'provinceRevenue': province_revenue.values.tolist(),
            'cities': [f"{idx[0]}-{idx[1]}" for idx in city_revenue.index],
            'cityRevenue': city_revenue.values.tolist(),
            'rawData': df[['省份', '城市', '总收入']].to_dict('records'),
            'total': {
                'totalProvinces': len(province_revenue),
                'totalCities': len(df),
                'totalRevenue': float(df['总收入'].sum())
            }
        }
        
        return jsonify({
            'success': True,
            'data': data,
            'timestamp': datetime.now().isoformat()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'获取地区热力图数据失败: {str(e)}'
        }), 500

@app.errorhandler(404)
def not_found(error):
    """404错误处理"""
    return jsonify({
        'success': False,
        'error': '接口不存在',
        'message': '请检查API路径是否正确'
    }), 404

@app.errorhandler(500)
def internal_error(error):
    """500错误处理"""
    return jsonify({
        'success': False,
        'error': '服务器内部错误',
        'message': '请联系管理员'
    }), 500

# ==================== AI智能分析接口 ====================

@app.route('/api/ai/data-summary', methods=['GET'])
def get_ai_data_summary():
    """获取AI数据概览"""
    try:
        summary = ai_service.get_data_summary()
        return jsonify({
            'success': True,
            'data': summary
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/ai/analyze-users', methods=['POST'])
def analyze_user_behavior():
    """用户行为分析"""
    try:
        analysis = ai_service.analyze_user_behavior()
        return jsonify({
            'success': True,
            'data': [{
                'title': '用户行为分析',
                'type': 'user',
                'analysis': analysis
            }]
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/ai/analyze-market', methods=['POST'])
def analyze_market_trend():
    """市场趋势分析"""
    try:
        analysis = ai_service.analyze_market_trend()
        return jsonify({
            'success': True,
            'data': [{
                'title': '市场趋势分析',
                'type': 'market',
                'analysis': analysis
            }]
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/ai/analyze-regions', methods=['POST'])
def analyze_regional_distribution():
    """区域分布分析"""
    try:
        analysis = ai_service.analyze_regional_distribution()
        return jsonify({
            'success': True,
            'data': [{
                'title': '区域分布分析',
                'type': 'region',
                'analysis': analysis
            }]
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/ai/analyze-revenue', methods=['POST'])
def analyze_revenue_optimization():
    """收入优化分析"""
    try:
        analysis = ai_service.revenue_optimization_analysis()
        return jsonify({
            'success': True,
            'data': [{
                'title': '收入优化分析',
                'type': 'revenue',
                'analysis': analysis
            }]
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/ai/chat', methods=['POST'])
def ai_chat():
    """AI智能问答"""
    try:
        data = request.get_json()
        question = data.get('question', '')

        if not question:
            return jsonify({
                'success': False,
                'error': '请输入问题'
            }), 400

        analysis = ai_service.chat_analysis(question)
        return jsonify({
            'success': True,
            'analysis': analysis,
            'type': 'chat',
            'question': question
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/ai/visualization-data', methods=['POST'])
def get_ai_visualization_data():
    """获取AI分析页面的可视化数据"""
    try:
        data = request.get_json()
        selected_data = data.get('selectedData', [])

        result = {}

        # 根据选择的数据类型返回相应的可视化数据
        cleaned_data_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'data', 'cleaned_data')

        if 'user' in selected_data:
            try:
                user_file = os.path.join(cleaned_data_path, 'user_table.csv')
                user_df = pd.read_csv(user_file, encoding='utf-8')
                result['user_analysis'] = {
                    'age_distribution': user_df['年龄'].value_counts().head(10).to_dict(),
                    'gender_distribution': user_df['性别'].value_counts().to_dict(),
                    'job_distribution': user_df['职业'].value_counts().head(10).to_dict()
                }
            except Exception as e:
                print(f"加载用户数据失败: {e}")
                # 添加模拟用户数据
                result['user_analysis'] = {
                    'age_distribution': {
                        '18-25岁': 320,
                        '26-35岁': 450,
                        '36-45岁': 280,
                        '46-55岁': 180,
                        '55岁以上': 120
                    },
                    'gender_distribution': {
                        '男': 680,
                        '女': 670
                    },
                    'job_distribution': {
                        '上班族': 420,
                        '学生': 380,
                        '自由职业': 250,
                        '服务业': 200,
                        '教师': 150,
                        '医生': 120,
                        '工程师': 180,
                        '销售': 160,
                        '其他': 130
                    }
                }

        if 'order' in selected_data:
            try:
                order_file = os.path.join(cleaned_data_path, 'order_table.csv')
                order_df = pd.read_csv(order_file, encoding='utf-8')
                result['order_analysis'] = {
                    'brand_distribution': order_df['品牌'].value_counts().to_dict(),
                    'price_distribution': order_df['单价'].value_counts().to_dict(),
                    'total_orders': len(order_df)
                }
            except Exception as e:
                print(f"加载订单数据失败: {e}")
                # 添加模拟订单数据
                result['order_analysis'] = {
                    'brand_distribution': {
                        '小电': 1250,
                        '街电': 980,
                        '怪兽充电': 850,
                        '来电': 720,
                        '搜电': 650,
                        '云充吧': 480,
                        '倍电': 380,
                        '美团充电': 320
                    },
                    'price_distribution': {
                        '1.0': 1200,
                        '1.5': 1800,
                        '2.0': 1500,
                        '2.5': 800,
                        '3.0': 600,
                        '3.5': 300,
                        '4.0': 200,
                        '5.0': 150
                    },
                    'total_orders': 6550
                }

        if 'region' in selected_data:
            try:
                region_file = os.path.join(cleaned_data_path, 'region_table.csv')
                region_df = pd.read_csv(region_file, encoding='utf-8')
                result['region_analysis'] = {
                    'province_distribution': region_df['省份'].value_counts().head(10).to_dict(),
                    'city_distribution': region_df['城市'].value_counts().head(10).to_dict()
                }
            except Exception as e:
                print(f"加载地区数据失败: {e}")
                # 添加模拟地区数据
                result['region_analysis'] = {
                    'province_distribution': {
                        '广东省': 1850,
                        '浙江省': 1620,
                        '江苏省': 1480,
                        '山东省': 1320,
                        '河南省': 1180,
                        '四川省': 980,
                        '湖北省': 850,
                        '湖南省': 780,
                        '河北省': 720,
                        '安徽省': 650
                    },
                    'city_distribution': {
                        '深圳市': 680,
                        '上海市': 650,
                        '北京市': 620,
                        '广州市': 580,
                        '杭州市': 520,
                        '南京市': 480,
                        '成都市': 450,
                        '武汉市': 420,
                        '西安市': 380,
                        '苏州市': 350
                    }
                }

        if 'time' in selected_data:
            try:
                # 加载时间维度表和订单数据
                time_file = os.path.join(cleaned_data_path, 'time_table.csv')
                order_file = os.path.join(cleaned_data_path, 'order_table.csv')

                time_df = pd.read_csv(time_file, encoding='utf-8')
                order_df = pd.read_csv(order_file, encoding='utf-8')

                # 生成基础时间分布
                weekday_distribution = time_df['星期'].value_counts().to_dict()
                month_distribution = time_df['年月中文'].value_counts().head(12).to_dict()

                # 从订单数据中提取真实的小时分布
                hourly_counts = {}
                for hour in range(24):
                    hourly_counts[f'{hour:02d}:00'] = 0

                # 统计开始时间的小时分布
                for _, row in order_df.iterrows():
                    start_time = str(row['开始时间'])
                    if ':' in start_time and start_time != '00:00':
                        try:
                            hour = int(start_time.split(':')[0])
                            if 0 <= hour <= 23:
                                hourly_counts[f'{hour:02d}:00'] += 1
                        except:
                            continue

                # 如果某些小时没有数据，用合理的值填充
                total_orders = sum(hourly_counts.values())
                if total_orders == 0:
                    # 使用模拟数据
                    hourly_counts = {
                        '00:00': 45, '01:00': 32, '02:00': 28, '03:00': 25,
                        '04:00': 22, '05:00': 35, '06:00': 85, '07:00': 180,
                        '08:00': 320, '09:00': 420, '10:00': 380, '11:00': 350,
                        '12:00': 480, '13:00': 520, '14:00': 450, '15:00': 380,
                        '16:00': 420, '17:00': 580, '18:00': 650, '19:00': 580,
                        '20:00': 480, '21:00': 380, '22:00': 280, '23:00': 150
                    }

                result['time_analysis'] = {
                    'weekday_distribution': weekday_distribution,
                    'month_distribution': month_distribution,
                    'total_days': len(time_df),
                    'hourly_distribution': hourly_counts
                }
            except Exception as e:
                print(f"加载时间数据失败: {e}")
                # 添加模拟时间数据
                result['time_analysis'] = {
                    'weekday_distribution': {
                        '星期一': 850,
                        '星期二': 920,
                        '星期三': 980,
                        '星期四': 1050,
                        '星期五': 1200,
                        '星期六': 1100,
                        '星期日': 900
                    },
                    'month_distribution': {
                        '2024年1月': 2800,
                        '2024年2月': 2600,
                        '2024年3月': 3200,
                        '2024年4月': 3100,
                        '2024年5月': 3400,
                        '2024年6月': 3600,
                        '2024年7月': 3800,
                        '2024年8月': 3500,
                        '2024年9月': 3300,
                        '2024年10月': 3200,
                        '2024年11月': 3000,
                        '2024年12月': 2900
                    },
                    'total_days': 365,
                    'hourly_distribution': {
                        '00:00': 45, '01:00': 32, '02:00': 28, '03:00': 25,
                        '04:00': 22, '05:00': 35, '06:00': 85, '07:00': 180,
                        '08:00': 320, '09:00': 420, '10:00': 380, '11:00': 350,
                        '12:00': 480, '13:00': 520, '14:00': 450, '15:00': 380,
                        '16:00': 420, '17:00': 580, '18:00': 650, '19:00': 580,
                        '20:00': 480, '21:00': 380, '22:00': 280, '23:00': 150
                    }
                }

        return jsonify({
            'success': True,
            'data': result
        })

    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/ai/analyze-time', methods=['POST'])
def analyze_time_data():
    """时间数据分析"""
    try:
        analysis = ai_service.analyze_time_patterns()
        return jsonify({
            'success': True,
            'data': [{
                'title': '时间数据分析',
                'type': 'time',
                'analysis': analysis
            }]
        })
    except Exception as e:
        print(f"时间数据分析失败: {str(e)}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

# ==================== 数据浏览接口 ====================

@app.route('/api/data/browse/<data_type>', methods=['GET'])
def browse_data(data_type):
    """获取原始CSV数据，支持分页"""
    try:
        # 文件映射
        file_mapping = {
            'user': 'user_table.csv',
            'order': 'order_table.csv',
            'region': 'region_table.csv',
            'time': 'time_table.csv'
        }
        
        # 检查数据类型是否有效
        if data_type not in file_mapping:
            return jsonify({
                'success': False,
                'error': '无效的数据类型',
                'message': f'支持的数据类型: {", ".join(file_mapping.keys())}'
            }), 400
        
        # 获取分页参数
        page = int(request.args.get('page', 1))
        page_size = int(request.args.get('page_size', 100))
        
        # 加载CSV数据
        df = load_cleaned_csv_data(file_mapping[data_type])
        if df is None:
            return jsonify({
                'success': False,
                'error': '数据加载失败',
                'message': f'无法加载 {file_mapping[data_type]} 文件'
            }), 500
        
        # 获取总记录数和总页数
        total_records = len(df)
        total_pages = (total_records + page_size - 1) // page_size
        
        # 计算分页索引
        start_idx = (page - 1) * page_size
        end_idx = min(start_idx + page_size, total_records)
        
        # 获取当前页的数据
        page_data = df.iloc[start_idx:end_idx]
        
        # 转换为JSON格式
        records = page_data.to_dict('records')
        columns = df.columns.tolist()
        
        return jsonify({
            'success': True,
            'data': {
                'records': records,
                'columns': columns,
                'pagination': {
                    'page': page,
                    'page_size': page_size,
                    'total_records': total_records,
                    'total_pages': total_pages
                },
                'file_name': file_mapping[data_type],
                'data_type': data_type
            },
            'timestamp': datetime.now().isoformat()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e),
            'message': '获取数据失败'
        }), 500

if __name__ == '__main__':
    print("🚀 共享充电宝数据仓库API服务启动中...")
    print(f"📁 数据路径: {DATA_PATH}")
    print("🌐 服务地址: http://localhost:5000")
    print("📖 API文档: http://localhost:5000")
    
    app.run(debug=True, host='0.0.0.0', port=5000)
